﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Linq.Expressions;
//using System.Reflection;
//using Freedom.Common;

//namespace Freedom.Framework.Utility
//{
//    public static class DataQueryHelper
//    {
//        public static IEnumerable<T> FilterBy<T>(this IEnumerable<T> colllection, string )

//        public static IEnumerable<T> FilterBy<T>(this IEnumerable<T> collection, IEnumerable<KeyValuePair<string, string>> query)
//        {
//            var filtersCount = int.Parse(query.SingleOrDefault(k => k.Key.Contains("filterscount")).Value);
            
//            Expression<Func<T, bool>> finalquery = null;

//            for (var i = 0; i < filtersCount; i += 1)
//            {
//                var filterValue = query.SingleOrDefault(k => k.Key.Contains("filtervalue" + i)).Value;
//                var filterCondition = query.SingleOrDefault(k => k.Key.Contains("filtercondition" + i)).Value;
//                EnumHelper.Parse<FilteCondition>(filterCondition);
//                var filterDataField = query.SingleOrDefault(k => k.Key.Contains("filterdatafield" + i)).Value;
//                var filterOperator = query.SingleOrDefault(k => k.Key.Contains("filteroperator" + i)).Value;

//                Expression<Func<T, bool>> current = n => IsMatchCondition(n, filterCondition, filterDataField, filterValue);

//                if (finalquery == null)
//                {
//                    finalquery = current;
//                }
//                else if (filterOperator == "1")
//                {
//                    finalquery = finalquery.Or(current);
//                }
//                else
//                {
//                    finalquery = finalquery.And(current);
//                }
//            };

//            if (finalquery != null)
//                collection = collection.AsQueryable().Where(finalquery);

//            return collection;
//        }


//        public static IEnumerable<T> SortBy<T>(this IEnumerable<T> collection, string sortField, SortType sort)
//        {
//            if (sort == SortType.Asc)
//            {
//                collection = collection.OrderBy(
//                    c => c.GetType().GetProperty(sortField, BindingFlags.IgnoreCase).GetValue(c, null));
//            }
//            else
//            {
//                collection = collection.OrderByDescending(
//                    c => c.GetType().GetProperty(sortField, BindingFlags.IgnoreCase).GetValue(c, null));
//            }
//            return collection;
//        }

//        private static bool IsMatchCondition<T>(T item, FilteCondition filterCondition, string filterDataField, string filterValue)
//        {
//            var fieldValue = item.GetType().GetProperty(filterDataField).GetValue(item).ToString();
//            switch (filterCondition)
//            {
//                case FilteCondition.Contains:
//                    return fieldValue.Contains(filterValue);
//                case FilteCondition.NotContains:
//                    return !fieldValue.Contains(filterValue);
//                case FilteCondition.Equal:
//                    return fieldValue.Equals(filterValue);
//                case FilteCondition.NotEqual:
//                    return !fieldValue.Equals(filterValue);
//                case FilteCondition.GT:
//                    return double.Parse(fieldValue) > double.Parse(filterValue);
//                case FilteCondition.LT:
//                    return double.Parse(fieldValue) < double.Parse(filterValue);
//                case FilteCondition.GTE:
//                    return double.Parse(fieldValue) >= double.Parse(filterValue);
//                case FilteCondition.LTE:
//                    return double.Parse(fieldValue) <= double.Parse(filterValue);
//                case FilteCondition.StartsWith:
//                    return !fieldValue.StartsWith(filterValue);
//                case FilteCondition.EndsWith:
//                    return !fieldValue.EndsWith(filterValue);
//                case FilteCondition.NotEmpty:
//                    return !string.IsNullOrEmpty(fieldValue);
//            }
//            return true;
//        }
//    }

//    public enum SortType
//    {
//        Asc,
//        Desc
//    }

   
//    /// <summary>
//    /// the filter condition
//    /// </summary>
//    public enum FilteCondition
//    {
//        /// <summary>
//        /// equal 
//        /// </summary>
//        Equal,
//        /// <summary>
//        /// not equal
//        /// </summary>
//        NotEqual,
//        /// <summary>
//        /// contains
//        /// </summary>
//        Contains,
//        /// <summary>
//        /// not contains
//        /// </summary>
//        NotContains,
//        /// <summary>
//        /// greate than
//        /// </summary>
//        GT,
//        /// <summary>
//        /// greate than or equal
//        /// </summary>
//        GTE,
//        /// <summary>
//        /// Less than
//        /// </summary>
//        LT,
//        /// <summary>
//        /// less than or equal
//        /// </summary>
//        LTE,
//        /// <summary>
//        /// In
//        /// </summary>
//        IN,
//        /// <summary>
//        /// Start with
//        /// </summary>
//        StartsWith,
//        /// <summary>
//        /// end with
//        /// </summary>
//        EndsWith,
//        /// <summary>
//        /// is null
//        /// </summary>
//        IsNull,
//        /// <summary>
//        /// not empty
//        /// </summary>
//        NotEmpty,
//        /// <summary>
//        /// like
//        /// </summary>
//        LIKE,
//        /// <summary>
//        /// not in 
//        /// </summary>
//        NotIn,
//        /// <summary>
//        /// Sort
//        /// </summary>
//        Order,
//    }

//}
